/**
 * 
 */
package com.yidu.drug.service.impl;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import com.yidu.drug.common.Line;
import com.yidu.drug.common.Page;
import com.yidu.drug.common.Sector;
import com.yidu.drug.common.Tools;
import com.yidu.drug.dao.DrugProductionModelMapper;
import com.yidu.drug.dao.PoBreakdownMapper;
import com.yidu.drug.dao.ProductionModelMapper;
import com.yidu.drug.dao.PurchaseOrderModelMapper;
import com.yidu.drug.dao.SalesStatisticsModelMapper;
import com.yidu.drug.model.DrugProductionModel;
import com.yidu.drug.model.PoBreakdown;
import com.yidu.drug.model.ProductionModel;
import com.yidu.drug.model.PurchaseOrderModel;
import com.yidu.drug.model.SalesStatisticsModel;
import com.yidu.drug.service.SalesStatisticsService;

/**
 * 销售统计表Service实现类
 * @author tanglei
 * @date 2018年8月27日 下午3:00:52
 * @version 1.0
 */
@Service
public class SalesStatisticsServiceImpl implements SalesStatisticsService{
	//注入销售统计Dao
	@Resource
	private SalesStatisticsModelMapper salesStatisticsDao;
	//注入生产计划单Dao
	@Resource
	private ProductionModelMapper productionDao;
	//注入药品生产计划Dao
	@Resource
	private DrugProductionModelMapper drugProductionDao;
	//注入采购订单Dao
	@Resource
	private PurchaseOrderModelMapper purchaseOrderDao;
	//注入采购明细Dao
	@Resource
	private PoBreakdownMapper poBreakdownDao;
	
	@Override
	public int insert(SalesStatisticsModel record) {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public int insertSelective(SalesStatisticsModel record) {
		// TODO Auto-generated method stub
		return 0;
	}

	/**
	 * 实现销售量折线统计图
	 * @param record 传入一个销售统计对象
	 * @return 返回一个map集合
	 */
	@Override
	public Map<String,Object> findAllSalesStatistics(SalesStatisticsModel record,String num) {
		//调用给销售统计对象里面分页和年份属性赋值的方法
		SalesStatisticsModel salesStatistics = setPageAndYear(record);
		//调用销售统计Dao里面的查询一年内每月销售数据的方法
		List<SalesStatisticsModel> list = salesStatisticsDao.findAllMonthSalesStatistics(salesStatistics);
		//调用销售统计Dao里面的查询每年销售数据的方法
		List<SalesStatisticsModel> lists = salesStatisticsDao.findAllYearSalesStatistics(salesStatistics);
		//调用销售统计Dao里面查询总行数的方法
		Long count = salesStatisticsDao.findRows(salesStatistics);
		
		//创建一个map集合
		Map<String,Object> map = new HashMap<String,Object>();
		
		//判断，如果num=1，则调用实现销量折线统计图的方法，如果为2，则调用实现销售排行统计表的方法
		if("1".equals(num)){
			//调用实现销量排行折线统计图的方法，传入list集合和lists集合
			map = xiaoShouTongJi(list,lists);
		}else if("2".equals(num)){
			//调用实现销售排行统计表的方法，传入list集合和lists集合，总行数
			map = xiaoShouPaiHang(list,lists,count);
		}
		//返回map集合
		return map;
	}

	/**
	 * 实现销售折线统计图的方法
	 * @param list 传入一个list集合
	 * @param lists 传入一个lists集合
	 * @return 返回一个map集合
	 */
	private Map<String,Object> xiaoShouTongJi(List<SalesStatisticsModel> list, List<SalesStatisticsModel> lists) {
		//创建一个Object数组
		Object[] str = new String[10];
		
		//得到去重复后的数据
		Object[] arr = removeDuplicate(list);
		
		//创建一个list集合
		List<Line> listLine = new ArrayList<Line>();
		//判断集合是否为空
		if(list.isEmpty()){
			//循环遍历list集和
			for(int i=0;i<10;i++){
				//创建一个long型数组
				int[] num = new int[12];
				//创建一个折线统计图模型
				Line line = new Line();
				//给折线统计图模型赋值
				line.setName("");
				line.setStack("销量");
				line.setType("line");
				//循环
				for(int j=0;j<12;j++){
					//给num数组赋值
					num[j] = 0;
				}
				//给折线统计图模型里面的data数组赋值
				line.setData(num);
				//将折线统计图模型添加到listLine集合中
				listLine.add(line);
			}
		}else {
			//循环遍历arr数组
			for(int i=0;i<arr.length;i++){
				//创建一个long型数组
				int[] num = new int[12];
				//创建一个折线统计图模型
				Line line = new Line();
				//给折线统计图模型赋值
				line.setName(String.valueOf(arr[i]));
				line.setStack("销量");
				line.setType("line");
				//循环遍历list集合
				for(int j=0;j<list.size();j++){
					//判断药品名称是否相同
					if(list.get(j).getDrugName().equals(arr[i])){
						//给str数组赋值 
						str[i] = arr[i];
						//判断
						if("01".equals(list.get(j).getSalesMonth())){
							num[0] = list.get(j).getSumNumber();
						}else if("02".equals(list.get(j).getSalesMonth())){
							num[1] = list.get(j).getSumNumber();
						}else if("03".equals(list.get(j).getSalesMonth())){
							num[2] = list.get(j).getSumNumber();
						}else if("04".equals(list.get(j).getSalesMonth())){
							num[3] = list.get(j).getSumNumber();
						}else if("05".equals(list.get(j).getSalesMonth())){
							num[4] = list.get(j).getSumNumber();
						}else if("06".equals(list.get(j).getSalesMonth())){
							num[5] = list.get(j).getSumNumber();
						}else if("07".equals(list.get(j).getSalesMonth())){
							num[6] = list.get(j).getSumNumber();
						}else if("08".equals(list.get(j).getSalesMonth())){
							num[7] = list.get(j).getSumNumber();
						}else if("09".equals(list.get(j).getSalesMonth())){
							num[8] = list.get(j).getSumNumber();
						}else if("10".equals(list.get(j).getSalesMonth())){
							num[9] = list.get(j).getSumNumber();
						}else if("11".equals(list.get(j).getSalesMonth())){
							num[10] = list.get(j).getSumNumber();
						}else if("12".equals(list.get(j).getSalesMonth())){
							num[11] = list.get(j).getSumNumber();
						}
					}
				}
				//给折线统计图模型里面的data数组赋值
				line.setData(num);
				//将折线统计图模型添加到listLine集合中
				listLine.add(line);
			}
		}
		//创建一个map集合
		Map<String,Object> map = new HashMap<String,Object>();
		//给map集合赋值
		map.put("drugName", str);
		map.put("list", listLine);
		//返回map集合
		return map;
	}

	/**
	 * 查询销售量排行数据(包括根据条件查询和分页)
	 * @param record 传入一个销售统计对象
	 * @return 返回一个map集合
	 */
	private Map<String, Object> xiaoShouPaiHang(List<SalesStatisticsModel> list, List<SalesStatisticsModel> lists,Long count) {
		//循环遍历集list集合
		for(int i=0;i<list.size();i++){
			//循环遍历lists集合
			for(int j=0;j<lists.size();j++){
				//判断药品名称是否相同
				if(list.get(i).getDrugName().equals(lists.get(j).getDrugName())){
					//list.get(i).setTotalNumber(lists.get(j).getSumNumber());
					//判断
					if("01".equals(list.get(i).getSalesMonth())){
						lists.get(j).setOneMonth(list.get(i).getSumNumber());
					}else if("02".equals(list.get(i).getSalesMonth())){
						lists.get(j).setTwoMonth(list.get(i).getSumNumber());
					}else if("03".equals(list.get(i).getSalesMonth())){
						lists.get(j).setThreeMonth(list.get(i).getSumNumber());
					}else if("04".equals(list.get(i).getSalesMonth())){
						lists.get(j).setFourMonth(list.get(i).getSumNumber());
					}else if("05".equals(list.get(i).getSalesMonth())){
						lists.get(j).setFiveMonth(list.get(i).getSumNumber());
					}else if("06".equals(list.get(i).getSalesMonth())){
						lists.get(j).setSixMonth(list.get(i).getSumNumber());
					}else if("07".equals(list.get(i).getSalesMonth())){
						lists.get(j).setSevenMonth(list.get(i).getSumNumber());
					}else if("08".equals(list.get(i).getSalesMonth())){
						lists.get(j).setEightMonth(list.get(i).getSumNumber());
					}else if("09".equals(list.get(i).getSalesMonth())){
						lists.get(j).setNineMonth(list.get(i).getSumNumber());
					}else if("10".equals(list.get(i).getSalesMonth())){
						lists.get(j).setTenMonth(list.get(i).getSumNumber());
					}else if("11".equals(list.get(i).getSalesMonth())){
						lists.get(j).setElevenMonth(list.get(i).getSumNumber());
					}else if("12".equals(list.get(i).getSalesMonth())){
						lists.get(j).setTwelveMonth(list.get(i).getSumNumber());
					}
				}
			}
		}
		//创建一个map集合
		Map<String,Object> map = new HashMap<String,Object>();
		//给map集合赋值
		map.put("code", 0);
		map.put("msg", "");
		map.put("count", count);
		map.put("data", lists);
		//返回map集合
		return map;
	}
	
	/**
	 * 去掉list集合中的重复字段
	 * @param list 传入 list集和 
	 * @return 返回一个Object数组
	 */
	public  Object[] removeDuplicate(List<SalesStatisticsModel> list){
		//实例化一个set集合(去重复)
		Set set = new HashSet();
		//循环遍历集合
		for(int i=0;i<list.size();i++){
			//给set集合赋值
			set.add(list.get(i).getDrugName());
		}
		//将set集合转换为数组形式
		Object[] arr =  set.toArray();
		//返回
		return arr;
	}
	
	/**
	 * 给销售统计表对象里面的分页对象属性和年份属性赋值
	 * @param record 传入一个销售统计对象
	 * @return 返回一个销售统计对象
	 */
	public SalesStatisticsModel setPageAndYear(SalesStatisticsModel record){
		//创建一个分页对象
		Page page = new Page();
		//给分页对象里面的页数属性赋值
		page.setPage(Integer.valueOf(record.getPage()));
		//给分页对象里面的每页显示行数属性赋值
		page.setRows(Integer.valueOf(record.getLimit()));
		//给销售统计表里面的分页对象赋值
		record.setPages(page);
		//判断，如果销售统计表对象的年份属性的值是否为null
		if(Tools.isEmpty(record.getSalesYear())){
			//创建一个日期类对象
			Date date = new Date();
			//创建一个日期格式转换对象(只需yyyy)
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
			//转换，将日期转换为字符串
			String salesYear = sdf.format(date);
			//给销售统计对象里面的年份属性赋值
			record.setSalesYear(salesYear);
		}
		//返回
		return record;
	}

	/**
	 * 实现每年的月成本总金额与月销售总金额对比图和月成本总金额与月总纯利润
	 */
	@Override
	public Map<String, Object> findTotalCostAllPriceAndSalesProfit(SalesStatisticsModel record,String num) {
		//创建一个int型数组
		int[] numOne = new int[12];
		//创建一个int型数组
		int[] numTwo = new int[12];
		//调用给销售统计对象里面分页和年份属性赋值的方法
		SalesStatisticsModel salesStatistics = setPageAndYear(record);
		//调用销售统计Dao里面的查询月成本总金额与月销售总金额
		List<SalesStatisticsModel> list = salesStatisticsDao.findTotalCostAllPriceAndSalesProfit(salesStatistics);
		//创建一个map集合
		Map<String,Object> map = new HashMap<String,Object>();
		//循环遍历list集合
		for(int i=0;i<list.size();i++){
			//给数组赋值
			/*numOne[i] = list.get(i).getSumCostAllPrice();
			numTwo[i] = (list.get(i).getSumSalesProfit()+list.get(i).getSumCostAllPrice());*/
			//判断月份是否相同
			if("01".equals(list.get(i).getSalesMonth())){
				if("1".equals(num)){
					numOne[0] = list.get(i).getSumCostAllPrice();
				}else if("2".equals(num)){
					numOne[0] = list.get(i).getSumSalesProfit();
				}
				numTwo[0] = (list.get(i).getSumSalesProfit()+list.get(i).getSumCostAllPrice());
			}else if("02".equals(list.get(i).getSalesMonth())){
				if("1".equals(num)){
					numOne[1] = list.get(i).getSumCostAllPrice();
				}else if("2".equals(num)){
					numOne[1] = list.get(i).getSumSalesProfit();
				}
				numTwo[1] = (list.get(i).getSumSalesProfit()+list.get(i).getSumCostAllPrice());
			}else if("03".equals(list.get(i).getSalesMonth())){
				if("1".equals(num)){
					numOne[2] = list.get(i).getSumCostAllPrice();
				}else if("2".equals(num)){
					numOne[2] = list.get(i).getSumSalesProfit();
				}
				numTwo[2] = (list.get(i).getSumSalesProfit()+list.get(i).getSumCostAllPrice());
			}else if("04".equals(list.get(i).getSalesMonth())){
				if("1".equals(num)){
					numOne[3] = list.get(i).getSumCostAllPrice();
				}else if("2".equals(num)){
					numOne[3] = list.get(i).getSumSalesProfit();
				}
				numTwo[3] = (list.get(i).getSumSalesProfit()+list.get(i).getSumCostAllPrice());
			}else if("05".equals(list.get(i).getSalesMonth())){
				if("1".equals(num)){
					numOne[4] = list.get(i).getSumCostAllPrice();
				}else if("2".equals(num)){
					numOne[4] = list.get(i).getSumSalesProfit();
				}
				numTwo[4] = (list.get(i).getSumSalesProfit()+list.get(i).getSumCostAllPrice());
			}else if("06".equals(list.get(i).getSalesMonth())){
				if("1".equals(num)){
					numOne[5] = list.get(i).getSumCostAllPrice();
				}else if("2".equals(num)){
					numOne[5] = list.get(i).getSumSalesProfit();
				}
				numTwo[5] = (list.get(i).getSumSalesProfit()+list.get(i).getSumCostAllPrice());
			}else if("07".equals(list.get(i).getSalesMonth())){
				if("1".equals(num)){
					numOne[6] = list.get(i).getSumCostAllPrice();
				}else if("2".equals(num)){
					numOne[6] = list.get(i).getSumSalesProfit();
				}
				numTwo[6] = (list.get(i).getSumSalesProfit()+list.get(i).getSumCostAllPrice());
			}else if("08".equals(list.get(i).getSalesMonth())){
				if("1".equals(num)){
					numOne[7] = list.get(i).getSumCostAllPrice();
				}else if("2".equals(num)){
					numOne[7] = list.get(i).getSumSalesProfit();
				}
				numTwo[7] = (list.get(i).getSumSalesProfit()+list.get(i).getSumCostAllPrice());
			}else if("09".equals(list.get(i).getSalesMonth())){
				if("1".equals(num)){
					numOne[8] = list.get(i).getSumCostAllPrice();
				}else if("2".equals(num)){
					numOne[8] = list.get(i).getSumSalesProfit();
				}
				numTwo[8] = (list.get(i).getSumSalesProfit()+list.get(i).getSumCostAllPrice());
			}else if("10".equals(list.get(i).getSalesMonth())){
				if("1".equals(num)){
					numOne[9] = list.get(i).getSumCostAllPrice();
				}else if("2".equals(num)){
					numOne[9] = list.get(i).getSumSalesProfit();
				}
				numTwo[9] = (list.get(i).getSumSalesProfit()+list.get(i).getSumCostAllPrice());
			}else if("11".equals(list.get(i).getSalesMonth())){
				if("1".equals(num)){
					numOne[10] = list.get(i).getSumCostAllPrice();
				}else if("2".equals(num)){
					numOne[10] = list.get(i).getSumSalesProfit();
				}
				numTwo[10] = (list.get(i).getSumSalesProfit()+list.get(i).getSumCostAllPrice());
			}else if("12".equals(list.get(i).getSalesMonth())){
				if("1".equals(num)){
					numOne[11] = list.get(i).getSumCostAllPrice();
				}else if("2".equals(num)){
					numOne[11] = list.get(i).getSumSalesProfit();
				}
				numTwo[1] = (list.get(i).getSumSalesProfit()+list.get(i).getSumCostAllPrice());
			}
		}
		//给map集合赋值
		map.put("numOne", numOne);
		map.put("numTwo", numTwo);
		//返回map集合
		return map;
	}

	/**
	 * 实现扇形统计图
	 */
	@Override
	public  List<Sector> findYearSumNumber(SalesStatisticsModel record) {
		//调用给销售统计对象里面分页和年份属性赋值的方法
		SalesStatisticsModel salesStatistics = setPageAndYear(record);
		//调用销售统计Dao里面的查询药品年销量的方法
		List<SalesStatisticsModel> list = salesStatisticsDao.findAllYearSalesStatistics(record);
		//调用销售统计对象里面的查询一年度年总销售量的方法
		Long sumNumber = salesStatisticsDao.findYearSumNumber(record);
		//创建一个list集合
		List<Sector> lists = new ArrayList<Sector>();
		//循环遍历list集合
		for(int i=0;i<list.size();i++){
			//得到其他的数量
			sumNumber -= list.get(i).getSumNumber();
			//创建一个扇形图形模型对象
			Sector sector = new Sector();
			//赋值
			sector.setValue(String.valueOf(list.get(i).getSumNumber()));
			sector.setName(list.get(i).getDrugName());
			//添加到lists集合中
			lists.add(sector);
		}
		//创建一个扇形图形模型对象
		Sector sector = new Sector();
		//赋值
		sector.setName("其他");
		sector.setValue(String.valueOf(sumNumber));
		lists.add(sector);
		//返回lists集合
		return lists;
	}

	/**
     * 查询今日或本月销量
     * @param record 传入一个销售统计对象
     * @return 返回一个销量的数量
     */
	@Override
	public Long findTodaysSalesOrMonthSales(SalesStatisticsModel record,String num) {
		//得到当前日期
		String date = Tools.getCurDate();
		//判断，如果num与1相同，则查询今日销量，如果num与2相同，则查询月销量
		if("1".equals(num)){
			//赋值
			record.setDate(date);
		}else if("2".equals(num)){
			//截取字符串，从0开始到第7位
			String str = date.substring(0,7);
			//赋值
			record.setDate(str);
		}
		//调用销售统计Dao里面的查询今日销量或月销量的方法
		Long number = salesStatisticsDao.findTodaysSalesOrMonthSales(record);
		//判断number是否为null
		if(number == null){
			//将number设置为0
			number = (long)0;
		}
		//返回number
		return number;
	}

	/**
     * 查询今日收入或本月收入(纯收入)
     * @param record 传入一个销售统计对象
     * @return 返回一个收入的金额
     */
	@Override
	public Double findTodaysIncomeOrMonthIncome(SalesStatisticsModel record,String num) {
		//得到当前日期
		String date = Tools.getCurDate();
		//判断，如果num与1相同，则查询今日销量，如果num与2相同，则查询月销量
		if("1".equals(num)){
			//赋值
			record.setDate(date);
		}else if("2".equals(num)){
			//截取字符串，从0开始到第7位
			String str = date.substring(0,7);
			//赋值
			record.setDate(str);
		}
		//调用销售统计Dao里面的查询今日收入或月收入的方法
		Double money = salesStatisticsDao.findTodaysIncomeOrMonthIncome(record);
		//判断money是否为null
		if(money == null){
			//设置money的值
			money = (double)0;
		}
		//返回money
		return money;
	}

	@Override
	public Map<String, Object> addProduction(ProductionModel pro, String startTime, String endTime) {
		try {
			//给生产计划单对象里面的开始时间属性赋值
			pro.setProDate(Tools.SDF_DATE.parse(startTime));
			//给生产计划单对象里面的结束时间属性赋值
			pro.setDueDate(Tools.SDF_DATE.parse(endTime));
		} catch (ParseException e) {
			e.printStackTrace();
		}
		//得到一个随机数
		String proId = Tools.getRandomUUID();
		//给生产计划单对象的生产计划ID属性赋值
		pro.setProId(proId);
		//给生产计划单对象的是否有效赋值
		pro.setIsva(Tools.ISVA_YES);
		//给生产计划单对象的制作状态赋值
		pro.setOperator("未制造");
		//调用生产计划单Dao的增加的方法，得到一个增加的行数
		int rows = productionDao.insertSelective(pro);
		//创建一个map集合
		Map<String,Object> map = new HashMap<String,Object>();
		//给map集合赋值
		map.put("rows", rows);
		map.put("proId", proId);
		return map;
	}

	/**
	 * 增加药品生产计划数据
	 * @param record 传入一个药品生产计划对象
	 * @return 返回一个影响的行数
	 */
	@Override
	public Map<String,Object> addDrugProduction(DrugProductionModel record) {
		//得到一个随机数
		String drpId = Tools.getRandomUUID();
		//给药品生产计划ID赋值
		record.setDrpId(drpId);
		//给药品生产计划的数量赋值
		record.setDrpNumber(0L);
		//给药品生产计划的是否有效赋值
		record.setIsva(Tools.ISVA_YES);
		//调用药品生产计划dao里面的增加的方法
		int rows = drugProductionDao.insertSelective(record);
		//创建一个map集合
		Map<String,Object> map = new HashMap<String,Object>();
		//给map集合赋值
		map.put("drpId", drpId);
		map.put("rows", rows);
		return map;
	}

	/**
     * 根据药品生产计划ID删除
     * @param drpId 传入一个药品生产计划ID
     * @return 返回一个影响的行数
     */
	@Override
	public int deleteDrugProduction(String drpId) {
		return drugProductionDao.deleteByPrimaryKey(drpId);
	}

	/**
     * 根据生产计划ID查询
     * @param proId 传入一个生产计划ID
     * @return 返回一个生产计划对象
     */
	@Override
	public ProductionModel findByProId(String proId) {
		// 调用生产计划dao里面的根据ID生产计划ID查询
		ProductionModel production = productionDao.selectByPrimaryKey(proId);
		//判断production是否为null
		if(production != null){
			//返回生产计划对象
			return production;
		}else {
			//创建一个生产计划对象
			ProductionModel productions = new ProductionModel();
			//给对象的属性赋值
			productions.setOperator("不存在");
			//返回生产计划对象
			return productions;
		}
	}

	/**
	 * 增加采购订单
	 * @param record 传入一个采购订单对象
	 * @return 返回一个map集合
	 */
	@Override
	public Map<String, Object> addPurchaseOrder(PurchaseOrderModel record) {
		//得到一个随机数
		String poId = Tools.getRandomUUID();
		//给采购订单对象里面的采购订单ID赋值
		record.setPoId(poId);
		//给采购订单对象里面的是否有效赋值
		record.setIsva(Tools.ISVA_YES);
		//new Date
		Date d = new Date();
		//给采购订单对象里面的采购时间赋值
		record.setPoTime(d);
		//给采购订单对象里面的采购状态赋值
		record.setPoState("未审核,未采购,未提交,未质检,未入库");
		//判断，判断采购备注是否为null
		if(!(record.getPoRemark()).equals("null")){
			
		}else{
			record.setPoRemark("暂无");
		}
		//调用采购订单dao里面的增加的方法
		int rows = purchaseOrderDao.insertSelective(record);
		//创建一个map集合
		Map<String,Object> map = new HashMap<String,Object>();
		//给map集合赋值
		map.put("rows", rows);
		map.put("poId", poId);
		//返回一个map集合
		return map;
	}

	/**
	 * 增加采购订单明细
	 * @param record 传入一个采购明细对象
	 * @return 返回map集合
	 */
	@Override
	public Map<String, Object> addPoBreakdown(PoBreakdown record) {
		//得到一个随机数
		String pobId = Tools.getRandomUUID();
		//给采购明细ID赋值
		record.setPobId(pobId);
		//给采购明细里面的备注赋值
		record.setPobRemark("暂无");
		//给采购明细里面的是否有效赋值
		record.setIsva(Tools.ISVA_YES);
		//给采购明细里面的数量赋值
		record.setPobNum(0);
		//调用采购明细里面的增加的方法
		int rows = poBreakdownDao.insertSelective(record);
		//创建一个map集合
		Map<String,Object> map = new HashMap<String,Object>();
		//给map集合赋值
		map.put("rows", rows);
		map.put("pobId", pobId);
		//返回map
		return map;
	}

	/**
	 * 根据采购明细ID删除
	 * @param pobId 传入一个采购明细ID
	 * @return 返回一个影响的行数
	 */
	@Override
	public int deletePoBreakdown(String pobId) {
		//调用采购明细dao里面的删除的方法
		return poBreakdownDao.deleteByPrimaryKey(pobId);
	}

	/**
	 * 根据采购订单ID查询
	 * @param poId 传入一个采购订单ID
	 * @return 返回一个采购订单对象
	 */
	@Override
	public PurchaseOrderModel findByPoId(String poId) {
		//调用采购订单dao里面的根据ID查询的方法
		PurchaseOrderModel purchaseOrder = purchaseOrderDao.selectByPrimaryKey(poId);
		//判断purchaseOrder是否为null
		if(purchaseOrder != null){
			//返回采购订单对象
			return purchaseOrder;
		}else {
			//创建一个采购订单对象
			PurchaseOrderModel purchaseOrders = new PurchaseOrderModel();
			//给采购订单对象的属性赋值
			purchaseOrders.setPoState("不存在");
			//返回才采购订单对象
			return purchaseOrders;
		}
		
	}

	/**
     * 根据生产计划ID查询药品生产计划
     * @param proId 传入一个生产计划ID
     * @return 返回一个list集合
     */
	@Override
	public List<DrugProductionModel> findByProIds(String proId) {
		// 调用药品生产计划Dao里面的根据生产计划ID查询的方法
		return drugProductionDao.findDrugIdByProId(proId);
	}

	/**
	 * 根据采购ID查询采购明细数据
	 * @param poId 传入一个采购ID
	 * @return 返回一个list集合
	 */
	@Override
	public List<PoBreakdown> findByPoIds(String poId) {
		// 调用采购订单明细Dao里面的根据采购ID查询的方法
		return poBreakdownDao.findMatIdByPoId(poId);
	}
}
